.TH std::regex_constants::error_type 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::regex_constants::error_type \- std::regex_constants::error_type

.SH Synopsis
   Defined in header <regex>
   using error_type = /* implementation-defined */;     \fB(1)\fP \fI(since C++11)\fP
   constexpr error_type error_collate =    /*
   unspecified */;

   constexpr error_type error_ctype =      /*
   unspecified */;
   constexpr error_type error_escape =     /*
   unspecified */;
   constexpr error_type error_backref =    /*
   unspecified */;
   constexpr error_type error_brack =      /*
   unspecified */;
   constexpr error_type error_paren =      /*
   unspecified */;
   constexpr error_type error_brace =      /*                             \fI(since C++11)\fP
   unspecified */;                                                        \fI(until C++17)\fP
   constexpr error_type error_badbrace =   /*
   unspecified */;
   constexpr error_type error_range =      /*
   unspecified */;
   constexpr error_type error_space =      /*
   unspecified */;
   constexpr error_type error_badrepeat =  /*
   unspecified */;
   constexpr error_type error_complexity = /*
   unspecified */;

   constexpr error_type error_stack =      /*
   unspecified */;                                      \fB(2)\fP
   inline constexpr error_type error_collate =    /*
   unspecified */;

   inline constexpr error_type error_ctype =      /*
   unspecified */;
   inline constexpr error_type error_escape =     /*
   unspecified */;
   inline constexpr error_type error_backref =    /*
   unspecified */;
   inline constexpr error_type error_brack =      /*
   unspecified */;
   inline constexpr error_type error_paren =      /*
   unspecified */;
   inline constexpr error_type error_brace =      /*                      \fI(since C++17)\fP
   unspecified */;
   inline constexpr error_type error_badbrace =   /*
   unspecified */;
   inline constexpr error_type error_range =      /*
   unspecified */;
   inline constexpr error_type error_space =      /*
   unspecified */;
   inline constexpr error_type error_badrepeat =  /*
   unspecified */;
   inline constexpr error_type error_complexity = /*
   unspecified */;

   inline constexpr error_type error_stack =      /*
   unspecified */;

   1) The error_type is a type that describes errors that may occur during regular
   expression parsing.

.SH Constants

   Constant         Explanation
   error_collate    the expression contains an invalid collating element name
   error_ctype      the expression contains an invalid character class name
   error_escape     the expression contains an invalid escaped character or a trailing
                    escape
   error_backref    the expression contains an invalid back reference
   error_brack      the expression contains mismatched square brackets ('[' and ']')
   error_paren      the expression contains mismatched parentheses ('(' and ')')
   error_brace      the expression contains mismatched curly braces ('{' and '}')
   error_badbrace   the expression contains an invalid range in a {} expression
   error_range      the expression contains an invalid character range (e.g. [b-a])
   error_space      there was not enough memory to convert the expression into a finite
                    state machine
   error_badrepeat  '*', '?', '+' or '{' was not preceded by a valid regular expression
   error_complexity the complexity of an attempted match exceeded a predefined level
   error_stack      there was not enough memory to perform a match

.SH Example

   Implements regular expressions checker:


// Run this code

 #include <cstddef>
 #include <iomanip>
 #include <iostream>
 #include <regex>
 #include <sstream>
 #include <string>

 void regular_expression_checker(const std::string& text,
                                 const std::string& regex,
                                 const std::regex::flag_type flags)
 {
     std::cout << "Text: " << std::quoted(text) << '\\n'
               << "Regex: " << std::quoted(regex) << '\\n';

     try
     {
         const std::regex re{regex, flags};
         const bool matched = std::regex_match(text, re);

         std::stringstream out;
         out << (matched ? "MATCH!\\n" : "DOES NOT MATCH!\\n");

         std::smatch m;
         if (std::regex_search(text, m, re); !m.empty())
         {
             out << "prefix = [" << m.prefix().str().data() << "]\\n";

             for (std::size_t i{}; i != m.size(); ++i)
                 out << "  m[" << i << "] = [" << m[i].str().data() << "]\\n";

             out << "suffix = [" << m.suffix().str().data() << "]\\n";
         }
         std::cout << out.str() << '\\n';
     }
     catch (std::regex_error& e)
     {
         std::cout << "Error: " << e.what() << ".\\n\\n";
     }
 }

 int main()
 {
     constexpr std::regex::flag_type your_flags
         = std::regex::flag_type{0}
     // Choose one of the supported grammars:
         | std::regex::ECMAScript
     //  | std::regex::basic
     //  | std::regex::extended
     //  | std::regex::awk
     //  | std::regex::grep
     //  | std::regex::egrep
     // Choose any of the next options:
     //  | std::regex::icase
     //  | std::regex::nosubs
     //  | std::regex::optimize
     //  | std::regex::collate
     //  | std::regex::multiline
         ;

     const std::string your_text = "Hello regular expressions.";
     const std::string your_regex = R"(([a-zA-Z]+) ([a-z]+) ([a-z]+)\\.)";
     regular_expression_checker(your_text, your_regex, your_flags);

     regular_expression_checker("Invalid!", R"(((.)(.))", your_flags);
     regular_expression_checker("Invalid!", R"([.)", your_flags);
     regular_expression_checker("Invalid!", R"([.]{})", your_flags);
     regular_expression_checker("Invalid!", R"([1-0])", your_flags);
 }

.SH Possible output:

 Text: "Hello regular expressions."
 Regex: "([a-zA-Z]+) ([a-z]+) ([a-z]+)\\\\."
 MATCH!
 prefix = []
   m[0] = [Hello regular expressions.]
   m[1] = [Hello]
   m[2] = [regular]
   m[3] = [expressions]
 suffix = []

 Text: "Invalid!"
 Regex: "((.)(.)"
 Error: Mismatched '(' and ')' in regular expression.

 Text: "Invalid!"
 Regex: "[."
 Error: Unexpected character within '[...]' in regular expression.

 Text: "Invalid!"
 Regex: "[.]{}"
 Error: Invalid range in '{}' in regular expression.

 Text: "Invalid!"
 Regex: "[1-0]"
 Error: Invalid range in bracket expression..

   Defect reports

   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.

      DR    Applied to       Behavior as published              Correct behavior
   LWG 2053 C++11      the constants were declared static removed the static specifier

.SH See also

   regex_error reports errors generated by the regular expressions library
   \fI(C++11)\fP     \fI(class)\fP
